ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ Node.js ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. ಸಿಂಕ್ರೊನಸ್, ಅಸಮಕಾಲಿಕ ಮತ್ತು ಸ್ಟ್ರೀಮ್-ಆಧಾರಿತ FS ವಿಧಾನಗಳು, ಟೈಪ್ ಸುರಕ್ಷತೆ, ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಇದು ವಿವರಿಸುತ್ತದೆ.
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಮಾಸ್ಟರಿ: ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಟೈಪ್ ಸೇಫ್ಟಿಯೊಂದಿಗೆ Node.js ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳು
ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ವಿಶಾಲ ಭೂದೃಶ್ಯದಲ್ಲಿ, ಸ್ಕೇಲೆಬಲ್ ಸರ್ವರ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಕಮಾಂಡ್-ಲೈನ್ ಉಪಕರಣಗಳು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ನಿರ್ಮಿಸಲು Node.js ಒಂದು ಶಕ್ತಿಶಾಲಿ ರನ್‌ಟೈಮ್ ಆಗಿ ನಿಂತಿದೆ. ಅನೇಕ Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಮೂಲಭೂತ ಅಂಶವು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ – ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಓದುವುದು, ಬರೆಯುವುದು, ರಚಿಸುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸಿದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪರಿಚಯವು ಸ್ಥಿರ ಟೈಪ್-ಚೆಕಿಂಗ್, ವರ್ಧಿತ ಟೂಲಿಂಗ್ ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಿಮ್ಮ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕೋಡ್‌ಗೆ ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ತರುವ ಮೂಲಕ ಈ ಅನುಭವವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ರಚಿಸಲಾಗಿದೆ, ಅವರ ಸಾಂಸ್ಕೃತಿಕ ಹಿನ್ನೆಲೆ ಅಥವಾ ಭೌಗೋಳಿಕ ಸ್ಥಳವನ್ನು ಲೆಕ್ಕಿಸದೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನೀಡುವ ದೃಢತೆಯೊಂದಿಗೆ Node.js ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುವವರು. ನಾವು ಪ್ರಮುಖ fs ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಅದರ ವಿವಿಧ ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಮಾದರಿಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಆಧುನಿಕ ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ API ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ಹೇಗೆ ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ಸ್ಪಷ್ಟತೆಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತೇವೆ.
ಮೂಲಾಧಾರ: Node.js ಫೈಲ್ ಸಿಸ್ಟಮ್ (fs) ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
Node.js fs ಮಾಡ್ಯೂಲ್ ಪ್ರಮಾಣಿತ POSIX ಕಾರ್ಯಗಳನ್ನು ಆಧರಿಸಿದ ರೀತಿಯಲ್ಲಿ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಮೂಲಭೂತ ಫೈಲ್ ಓದುವಿಕೆ ಮತ್ತು ಬರೆಯುವಿಕೆಯಿಂದ ಸಂಕೀರ್ಣ ಡೈರೆಕ್ಟರಿ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳು ಮತ್ತು ಫೈಲ್ ವಾಚಿಂಗ್‌ವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ. ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತಿತ್ತು, ಇದು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಕುಖ್ಯಾತ "ಕಾಲ್‌ಬ್ಯಾಕ್ ಹೆಲ್" ಗೆ ಕಾರಣವಾಯಿತು. Node.js ನ ವಿಕಾಸದೊಂದಿಗೆ, ಪ್ರಾಮಿಸ್‌ಗಳು ಮತ್ತು async/await ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಆದ್ಯತೆಯ ಮಾದರಿಗಳಾಗಿ ಹೊರಹೊಮ್ಮಿವೆ, ಇದು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲದು.
ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಏಕೆ?
Node.js ನ fs ಮಾಡ್ಯೂಲ್ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದರಿಂದ ಹಲವಾರು ಆಕರ್ಷಕ ಪ್ರಯೋಜನಗಳನ್ನು ತರುತ್ತದೆ:
- ಟೈಪ್ ಸೇಫ್ಟಿ: ಸಂಕಲನದ ಸಮಯದಲ್ಲಿ, ನಿಮ್ಮ ಕೋಡ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಮೊದಲು, ತಪ್ಪಾದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರಕಾರಗಳು, ಕಾಣೆಯಾದ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳಂತಹ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ಹಿಡಿದಿಡುತ್ತದೆ. ಇದು ಅಮೂಲ್ಯವಾದುದು, ವಿಶೇಷವಾಗಿ ವಿವಿಧ ಫೈಲ್ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳು, ಫ್ಲಾಗ್‌ಗಳು ಮತ್ತು
Bufferಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. - ವರ್ಧಿತ ಓದುವಿಕೆ: ಸ್ಪಷ್ಟ ಟೈಪ್ ಅನಾಟೇಶನ್‌ಗಳು ಕಾರ್ಯವು ಯಾವ ರೀತಿಯ ಡೇಟಾವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಏನನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ, ವಿವಿಧ ತಂಡಗಳಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕೋಡ್ ಗ್ರಹಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
- ಉತ್ತಮ ಟೂಲಿಂಗ್ ಮತ್ತು ಆಟೊಕಂಪ್ಲೀಷನ್: IDE ಗಳು (VS ಕೋಡ್‌ನಂತಹ) ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಬುದ್ಧಿವಂತ ಆಟೊಕಂಪ್ಲೀಷನ್, ಪ್ಯಾರಾಮೀಟರ್ ಸುಳಿವುಗಳು ಮತ್ತು ಇನ್‌ಲೈನ್ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಒದಗಿಸಲು ಬಳಸುತ್ತವೆ, ಇದು ಉತ್ಪಾದಕತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ.
- ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ವಿಶ್ವಾಸ: ನೀವು ಇಂಟರ್ಫೇಸ್ ಅಥವಾ ಕಾರ್ಯದ ಸಹಿಯನ್ನು ಬದಲಾಯಿಸಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ತಕ್ಷಣವೇ ಎಲ್ಲಾ ಬಾಧಿತ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ, ದೊಡ್ಡ ಪ್ರಮಾಣದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಕಡಿಮೆ ದೋಷಪೂರಿತವಾಗಿಸುತ್ತದೆ.
- ಜಾಗತಿಕ ಸ್ಥಿರತೆ: ಅಂತರರಾಷ್ಟ್ರೀಯ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಾದ್ಯಂತ ಸ್ಥಿರವಾದ ಕೋಡಿಂಗ್ ಶೈಲಿ ಮತ್ತು ಡೇಟಾ ರಚನೆಗಳ ತಿಳುವಳಿಕೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ, ಅಸ್ಪಷ್ಟತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಸಿಂಕ್ರೊನಸ್ vs. ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು: ಒಂದು ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನ
ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ, ವಿಶೇಷವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾಶೀಲತೆ ಪ್ರಮುಖವಾಗಿರುವ ಜಾಗತಿಕ ನಿಯೋಜನೆಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ. ಹೆಚ್ಚಿನ fs ಮಾಡ್ಯೂಲ್ ಕಾರ್ಯಗಳು ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಸ್ವರೂಪಗಳಲ್ಲಿ ಬರುತ್ತವೆ. ನಿಯಮದಂತೆ, ಅಸಮಕಾಲಿಕ ವಿಧಾನಗಳನ್ನು ನಾನ್-ಬ್ಲಾಕಿಂಗ್ I/O ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ, ಇದು ನಿಮ್ಮ Node.js ಸರ್ವರ್‌ನ ಪ್ರತಿಕ್ರಿಯಾಶೀಲತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಅತ್ಯಗತ್ಯ.
- ಅಸಮಕಾಲಿಕ (ನಾನ್-ಬ್ಲಾಕಿಂಗ್): ಈ ವಿಧಾನಗಳು ತಮ್ಮ ಕೊನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ ಅಥವಾ
Promiseಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ. ಅವು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತವೆ ಮತ್ತು ತಕ್ಷಣವೇ ಹಿಂದಿರುಗುತ್ತವೆ, ಇತರ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡಾಗ, ಕಾಲ್‌ಬ್ಯಾಕ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ (ಅಥವಾ ಪ್ರಾಮಿಸ್ ಪರಿಹರಿಸುತ್ತದೆ/ನಿರಾಕರಿಸುತ್ತದೆ). ಇದು ಪ್ರಪಂಚದಾದ್ಯಂತದ ಬಳಕೆದಾರರಿಂದ ಅನೇಕ ಏಕಕಾಲಿಕ ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸರ್ವರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಕಾಯುತ್ತಿರುವಾಗ ಸರ್ವರ್ ಅನ್ನು ಫ್ರೀಜ್ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ. - ಸಿಂಕ್ರೊನಸ್ (ಬ್ಲಾಕಿಂಗ್): ಈ ವಿಧಾನಗಳು ಹಿಂದಿರುಗುವ ಮೊದಲು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ. ಕೋಡ್ ಮಾಡಲು ಸರಳವಾಗಿದ್ದರೂ, ಅವು Node.js ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತವೆ, ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆ ಮುಗಿಯುವವರೆಗೆ ಯಾವುದೇ ಇತರ ಕೋಡ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಇದು ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆ ಬಾಟಲ್‌ನೆಕ್‌ಗಳು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಿಸದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚಿನ-ಟ್ರಾಫಿಕ್ ಪರಿಸರಗಳಲ್ಲಿ. ಅವುಗಳನ್ನು ಮಿತವಾಗಿ ಬಳಸಿ, ಸಾಮಾನ್ಯವಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಸ್ಟಾರ್ಟಪ್ ಲಾಜಿಕ್ ಅಥವಾ ಬ್ಲಾಕಿಂಗ್ ಸ್ವೀಕಾರಾರ್ಹವಾದ ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗಾಗಿ.
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಮುಖ್ಯ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಯ ಪ್ರಕಾರಗಳು
ಸಾಮಾನ್ಯ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಕ್ಕೆ ಹೋಗೋಣ. ನಾವು Node.js ಗಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ @types/node ಪ್ಯಾಕೇಜ್ ಮೂಲಕ ಲಭ್ಯವಿರುತ್ತದೆ.
ಪ್ರಾರಂಭಿಸಲು, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು Node.js ಟೈಪ್‌ಗಳು ಸ್ಥಾಪನೆಯಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:
npm install typescript @types/node --save-dev
ನಿಮ್ಮ tsconfig.json ಅನ್ನು ಸೂಕ್ತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು, ಉದಾಹರಣೆಗೆ:
{
"compilerOptions": {
"target": "es2020",
"module": "commonjs",
"outDir": "./dist",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
},
"include": ["src/**/*"]
}
ಫೈಲ್‌ಗಳನ್ನು ಓದುವುದು: readFile, readFileSync, ಮತ್ತು Promises API
ಫೈಲ್‌ಗಳಿಂದ ವಿಷಯವನ್ನು ಓದುವುದು ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ. ಫೈಲ್ ಪಾತ್‌ಗಳು, ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳು ಮತ್ತು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ನೀವು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತೀರಿ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಫೈಲ್ ಓದುವಿಕೆ (ಕಾಲ್‌ಬ್ಯಾಕ್-ಆಧಾರಿತ)
fs.readFile ಕಾರ್ಯವು ಅಸಮಕಾಲಿಕ ಫೈಲ್ ಓದುವಿಕೆಗೆ ಮುಖ್ಯ ಕಾರ್ಯವಾಗಿದೆ. ಇದು ಪಾತ್, ಐಚ್ಛಿಕ ಎನ್‌ಕೋಡಿಂಗ್ ಮತ್ತು ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಾಲ್‌ಬ್ಯಾಕ್‌ನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಸರಿಯಾಗಿ ಟೈಪ್ ಆಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ (Error | null, Buffer | string).
import * as fs from 'fs';
const filePath: string = 'data/example.txt';
fs.readFile(filePath, 'utf8', (err: NodeJS.ErrnoException | null, data: string) => {
if (err) {
// Log error for international debugging, e.g., 'File not found'
console.error(`Error reading file '${filePath}': ${err.message}`);
return;
}
// Process file content, ensuring it's a string as per 'utf8' encoding
console.log(`File content (${filePath}):\n${data}`);
});
// Example: Reading binary data (no encoding specified)
const binaryFilePath: string = 'data/image.png';
fs.readFile(binaryFilePath, (err: NodeJS.ErrnoException | null, data: Buffer) => {
if (err) {
console.error(`Error reading binary file '${binaryFilePath}': ${err.message}`);
return;
}
// 'data' is a Buffer here, ready for further processing (e.g., streaming to a client)
console.log(`Read ${data.byteLength} bytes from ${binaryFilePath}`);
});
ಸಿಂಕ್ರೊನಸ್ ಫೈಲ್ ಓದುವಿಕೆ
fs.readFileSync ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ. ಅದರ ರಿಟರ್ನ್ ಟೈಪ್ Buffer ಅಥವಾ string ಆಗಿದ್ದು, ಎನ್‌ಕೋಡಿಂಗ್ ಒದಗಿಸಲಾಗಿದೆಯೇ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇದನ್ನು ಸರಿಯಾಗಿ ಊಹಿಸುತ್ತದೆ.
import * as fs from 'fs';
const syncFilePath: string = 'data/sync_example.txt';
try {
const content: string = fs.readFileSync(syncFilePath, 'utf8');
console.log(`Synchronous read content (${syncFilePath}):\n${content}`);
} catch (error: any) {
console.error(`Synchronous read error for '${syncFilePath}': ${error.message}`);
}
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಫೈಲ್ ಓದುವಿಕೆ (fs/promises)
ಆಧುನಿಕ fs/promises API ಕ್ಲೀನರ್, ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದನ್ನು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇಲ್ಲಿ ಉತ್ತಮವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ async/await ನೊಂದಿಗೆ.
import * as fsPromises from 'fs/promises';
async function readTextFile(path: string): Promise
ಫೈಲ್‌ಗಳನ್ನು ಬರೆಯುವುದು: writeFile, writeFileSync, ಮತ್ತು Flags
ಫೈಲ್‌ಗಳಿಗೆ ಡೇಟಾವನ್ನು ಬರೆಯುವುದು ಅಷ್ಟೇ ಮುಖ್ಯ. ಫೈಲ್ ಪಾತ್‌ಗಳು, ಡೇಟಾ ಪ್ರಕಾರಗಳು (ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ Buffer), ಎನ್‌ಕೋಡಿಂಗ್ ಮತ್ತು ಫೈಲ್ ಓಪನ್ ಫ್ಲಾಗ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಫೈಲ್ ಬರೆಯುವಿಕೆ
fs.writeFile ಅನ್ನು ಫೈಲ್‌ಗೆ ಡೇಟಾವನ್ನು ಬರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ, ಫೈಲ್ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಅದನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ. ನೀವು flags ಮೂಲಕ ಈ ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಬಹುದು.
import * as fs from 'fs';
const outputFilePath: string = 'data/output.txt';
const fileContent: string = 'This is new content written by TypeScript.';
fs.writeFile(outputFilePath, fileContent, 'utf8', (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error writing file '${outputFilePath}': ${err.message}`);
return;
}
console.log(`File '${outputFilePath}' written successfully.`);
});
// Example with Buffer data
const bufferContent: Buffer = Buffer.from('Binary data example');
const binaryOutputFilePath: string = 'data/binary_output.bin';
fs.writeFile(binaryOutputFilePath, bufferContent, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error writing binary file '${binaryOutputFilePath}': ${err.message}`);
return;
}
console.log(`Binary file '${binaryOutputFilePath}' written successfully.`);
});
ಸಿಂಕ್ರೊನಸ್ ಫೈಲ್ ಬರೆಯುವಿಕೆ
fs.writeFileSync ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.
import * as fs from 'fs';
const syncOutputFilePath: string = 'data/sync_output.txt';
try {
fs.writeFileSync(syncOutputFilePath, 'Synchronously written content.', 'utf8');
console.log(`File '${syncOutputFilePath}' written synchronously.`);
} catch (error: any) {
console.error(`Synchronous write error for '${syncOutputFilePath}': ${error.message}`);
}
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಫೈಲ್ ಬರೆಯುವಿಕೆ (fs/promises)
async/await ಮತ್ತು fs/promises ನೊಂದಿಗೆ ಆಧುನಿಕ ವಿಧಾನವು ಅಸಮಕಾಲಿಕ ಬರವಣಿಗೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚಾಗಿ ಕ್ಲೀನರ್ ಆಗಿದೆ.
import * as fsPromises from 'fs/promises';
import { constants as fsConstants } from 'fs'; // For flags
async function writeDataToFile(path: string, data: string | Buffer): Promise
ಪ್ರಮುಖ ಫ್ಲಾಗ್‌ಗಳು:
- `'w'` (default): ಬರೆಯಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ (ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ) ಅಥವಾ ಕತ್ತರಿಸಲಾಗಿದೆ (ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ).
- `'w+'`: ಓದಲು ಮತ್ತು ಬರೆಯಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ (ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ) ಅಥವಾ ಕತ್ತರಿಸಲಾಗಿದೆ (ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ).
- `'a'` (append): ಸೇರಿಸಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ರಚಿಸಲಾಗಿದೆ.
- `'a+'`: ಓದಲು ಮತ್ತು ಸೇರಿಸಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ರಚಿಸಲಾಗಿದೆ.
- `'r'` (read): ಓದಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅಸಾಧಾರಣ ಪರಿಸ್ಥಿತಿ ಸಂಭವಿಸುತ್ತದೆ.
- `'r+'`: ಓದಲು ಮತ್ತು ಬರೆಯಲು ಫೈಲ್ ತೆರೆಯಿರಿ. ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅಸಾಧಾರಣ ಪರಿಸ್ಥಿತಿ ಸಂಭವಿಸುತ್ತದೆ.
- `'wx'` (exclusive write): `'w'` ನಂತೆ ಆದರೆ ಪಾತ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.
- `'ax'` (exclusive append): `'a'` ನಂತೆ ಆದರೆ ಪಾತ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.
ಫೈಲ್‌ಗಳಿಗೆ ಸೇರಿಸುವುದು: appendFile, appendFileSync
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫೈಲ್‌ನ ವಿಷಯವನ್ನು ಅತಿಕ್ರಮಿಸದೆ ಅದರ ಕೊನೆಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಸೇರಿಸಬೇಕಾದಾಗ, appendFile ನಿಮ್ಮ ಆಯ್ಕೆಯಾಗಿದೆ. ಇದು ಲಾಗಿಂಗ್, ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಅಥವಾ ಆಡಿಟ್ ಟ್ರೇಲ್‌ಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
ಅಸಮಕಾಲಿಕ ಸೇರಿಸುವಿಕೆ
import * as fs from 'fs';
const logFilePath: string = 'data/app_logs.log';
function logMessage(message: string): void {
const timestamp: string = new Date().toISOString();
const logEntry: string = `${timestamp} - ${message}\n`;
fs.appendFile(logFilePath, logEntry, 'utf8', (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error appending to log file '${logFilePath}': ${err.message}`);
return;
}
console.log(`Logged message to '${logFilePath}'.`);
});
}
logMessage('User "Alice" logged in.');
setTimeout(() => logMessage('System update initiated.'), 50);
logMessage('Database connection established.');
ಸಿಂಕ್ರೊನಸ್ ಸೇರಿಸುವಿಕೆ
import * as fs from 'fs';
const syncLogFilePath: string = 'data/sync_app_logs.log';
function logMessageSync(message: string): void {
const timestamp: string = new Date().toISOString();
const logEntry: string = `${timestamp} - ${message}\n`;
try {
fs.appendFileSync(syncLogFilePath, logEntry, 'utf8');
console.log(`Logged message synchronously to '${syncLogFilePath}'.`);
} catch (error: any) {
console.error(`Synchronous error appending to log file '${syncLogFilePath}': ${error.message}`);
}
}
logMessageSync('Application started.');
logMessageSync('Configuration loaded.');
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಸೇರಿಸುವಿಕೆ (fs/promises)
import * as fsPromises from 'fs/promises';
const promiseLogFilePath: string = 'data/promise_app_logs.log';
async function logMessagePromise(message: string): Promise
ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸುವುದು: unlink, unlinkSync
ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ಫೈಲ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು. ನೀವು ಮಾನ್ಯವಾದ ಪಾತ್ ಅನ್ನು ರವಾನಿಸುತ್ತಿದ್ದೀರಿ ಮತ್ತು ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಅಳಿಸುವಿಕೆ
import * as fs from 'fs';
const fileToDeletePath: string = 'data/temp_to_delete.txt';
// First, create the file to ensure it exists for deletion demo
fs.writeFile(fileToDeletePath, 'Temporary content.', 'utf8', (err) => {
if (err) {
console.error('Error creating file for deletion demo:', err);
return;
}
console.log(`File '${fileToDeletePath}' created for deletion demo.`);
fs.unlink(fileToDeletePath, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error deleting file '${fileToDeletePath}': ${err.message}`);
return;
}
console.log(`File '${fileToDeletePath}' deleted successfully.`);
});
});
ಸಿಂಕ್ರೊನಸ್ ಅಳಿಸುವಿಕೆ
import * as fs from 'fs';
const syncFileToDeletePath: string = 'data/sync_temp_to_delete.txt';
try {
fs.writeFileSync(syncFileToDeletePath, 'Sync temp content.', 'utf8');
console.log(`File '${syncFileToDeletePath}' created.`);
fs.unlinkSync(syncFileToDeletePath);
console.log(`File '${syncFileToDeletePath}' deleted synchronously.`);
} catch (error: any) {
console.error(`Synchronous deletion error for '${syncFileToDeletePath}': ${error.message}`);
}
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಅಳಿಸುವಿಕೆ (fs/promises)
import * as fsPromises from 'fs/promises';
const promiseFileToDeletePath: string = 'data/promise_temp_to_delete.txt';
async function deleteFile(path: string): Promise
ಫೈಲ್ ಅಸ್ತಿತ್ವ ಮತ್ತು ಅನುಮತಿಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು: existsSync, access, accessSync
ಫೈಲ್‌ನಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಡೆಸುವ ಮೊದಲು, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಅಥವಾ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ ಅಗತ್ಯ ಅನುಮತಿಗಳಿವೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬೇಕಾಗಬಹುದು. mode ಪ್ಯಾರಾಮೀಟರ್‌ಗಾಗಿ ಪ್ರಕಾರಗಳನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಸಿಂಕ್ರೊನಸ್ ಅಸ್ತಿತ್ವ ಪರಿಶೀಲನೆ
fs.existsSync ಒಂದು ಸರಳ, ಸಿಂಕ್ರೊನಸ್ ಪರಿಶೀಲನೆಯಾಗಿದೆ. ಅನುಕೂಲಕರವಾಗಿದ್ದರೂ, ಇದು ರೇಸ್ ಕಂಡೀಶನ್ ದುರ್ಬಲತೆಯನ್ನು ಹೊಂದಿದೆ (existsSync ಮತ್ತು ನಂತರದ ಕಾರ್ಯಾಚರಣೆಯ ನಡುವೆ ಫೈಲ್ ಅನ್ನು ಅಳಿಸಬಹುದು), ಆದ್ದರಿಂದ ನಿರ್ಣಾಯಕ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ fs.access ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ.
import * as fs from 'fs';
const checkFilePath: string = 'data/example.txt';
if (fs.existsSync(checkFilePath)) {
console.log(`File '${checkFilePath}' exists.`);
} else {
console.log(`File '${checkFilePath}' does not exist.`);
}
ಅಸಮಕಾಲಿಕ ಅನುಮತಿ ಪರಿಶೀಲನೆ (fs.access)
fs.access path ನಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿಗಾಗಿ ಬಳಕೆದಾರರ ಅನುಮತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಇದು ಅಸಮಕಾಲಿಕವಾಗಿದೆ ಮತ್ತು mode ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (ಉದಾ., ಅಸ್ತಿತ್ವಕ್ಕಾಗಿ fs.constants.F_OK, ಓದಲು R_OK, ಬರೆಯಲು W_OK, ಕಾರ್ಯಗತಗೊಳಿಸಲು X_OK).
import * as fs from 'fs';
import { constants } from 'fs';
const accessFilePath: string = 'data/example.txt';
fs.access(accessFilePath, constants.F_OK, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`File '${accessFilePath}' does not exist or access denied.`);
return;
}
console.log(`File '${accessFilePath}' exists.`);
});
fs.access(accessFilePath, constants.R_OK | constants.W_OK, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`File '${accessFilePath}' is not readable/writable or access denied: ${err.message}`);
return;
}
console.log(`File '${accessFilePath}' is readable and writable.`);
});
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಅನುಮತಿ ಪರಿಶೀಲನೆ (fs/promises)
import * as fsPromises from 'fs/promises';
import { constants } from 'fs';
async function checkFilePermissions(path: string, mode: number): Promise
ಫೈಲ್ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವುದು: stat, statSync, fs.Stats
fs.stat ಕಾರ್ಯಗಳ ಕುಟುಂಬವು ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿಯ ಬಗ್ಗೆ ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಗಾತ್ರ, ರಚನೆ ದಿನಾಂಕ, ಮಾರ್ಪಾಡು ದಿನಾಂಕ ಮತ್ತು ಅನುಮತಿಗಳು. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ fs.Stats ಇಂಟರ್ಫೇಸ್ ಈ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಹೆಚ್ಚು ರಚನಾತ್ಮಕ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹಗೊಳಿಸುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಸ್ಟ್ಯಾಟ್
import * as fs from 'fs';
import { Stats } from 'fs';
const statFilePath: string = 'data/example.txt';
fs.stat(statFilePath, (err: NodeJS.ErrnoException | null, stats: Stats) => {
if (err) {
console.error(`Error getting stats for '${statFilePath}': ${err.message}`);
return;
}
console.log(`Stats for '${statFilePath}':`);
console.log(` Is file: ${stats.isFile()}`);
console.log(` Is directory: ${stats.isDirectory()}`);
console.log(` Size: ${stats.size} bytes`);
console.log(` Creation time: ${stats.birthtime.toISOString()}`);
console.log(` Last modified: ${stats.mtime.toISOString()}`);
});
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಸ್ಟ್ಯಾಟ್ (fs/promises)
import * as fsPromises from 'fs/promises';
import { Stats } from 'fs'; // Still use the 'fs' module's Stats interface
async function getFileStats(path: string): Promise
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಡೈರೆಕ್ಟರಿ ಕಾರ್ಯಾಚರಣೆಗಳು
ಫೈಲ್‌ಗಳನ್ನು ಸಂಘಟಿಸಲು, ಅಪ್ಲಿಕೇಶನ್-ನಿರ್ದಿಷ್ಟ ಸಂಗ್ರಹಣೆಯನ್ನು ರಚಿಸಲು ಅಥವಾ ತಾತ್ಕಾಲಿಕ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೃಢವಾದ ಟೈಪಿಂಗ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸುವುದು: mkdir, mkdirSync
ಹೊಸ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸಲು fs.mkdir ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. recursive ಆಯ್ಕೆಯು ಪೋಷಕ ಡೈರೆಕ್ಟರಿಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅವುಗಳನ್ನು ರಚಿಸಲು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ, ಇದು ಯೂನಿಕ್ಸ್-ತರಹದ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ mkdir -p ನ ನಡವಳಿಕೆಯನ್ನು ಅನುಕರಿಸುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಡೈರೆಕ್ಟರಿ ರಚನೆ
import * as fs from 'fs';
const newDirPath: string = 'data/new_directory';
const recursiveDirPath: string = 'data/nested/path/to/create';
// Create a single directory
fs.mkdir(newDirPath, (err: NodeJS.ErrnoException | null) => {
if (err) {
// Ignore EEXIST error if directory already exists
if (err.code === 'EEXIST') {
console.log(`Directory '${newDirPath}' already exists.`);
} else {
console.error(`Error creating directory '${newDirPath}': ${err.message}`);
}
return;
}
console.log(`Directory '${newDirPath}' created successfully.`);
});
// Create nested directories recursively
fs.mkdir(recursiveDirPath, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
if (err.code === 'EEXIST') {
console.log(`Directory '${recursiveDirPath}' already exists.`);
} else {
console.error(`Error creating recursive directory '${recursiveDirPath}': ${err.message}`);
}
return;
}
console.log(`Recursive directories '${recursiveDirPath}' created successfully.`);
});
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಡೈರೆಕ್ಟರಿ ರಚನೆ (fs/promises)
import * as fsPromises from 'fs/promises';
async function createDirectory(path: string, recursive: boolean = false): Promise
ಡೈರೆಕ್ಟರಿ ವಿಷಯಗಳನ್ನು ಓದುವುದು: readdir, readdirSync, fs.Dirent
ನೀಡಿದ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ ಫೈಲ್‌ಗಳು ಮತ್ತು ಉಪಡೈರೆಕ್ಟರಿಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಲು, ನೀವು fs.readdir ಅನ್ನು ಬಳಸುತ್ತೀರಿ. withFileTypes ಆಯ್ಕೆಯು ಒಂದು ಆಧುನಿಕ ಸೇರ್ಪಡೆಯಾಗಿದ್ದು, fs.Dirent ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇದು ಪ್ರತಿಯೊಂದು ನಮೂದನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ stat ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದೆ ಹೆಚ್ಚು ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು ನೇರವಾಗಿ ಒದಗಿಸುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಡೈರೆಕ್ಟರಿ ಓದುವಿಕೆ
import * as fs from 'fs';
const readDirPath: string = 'data';
fs.readdir(readDirPath, (err: NodeJS.ErrnoException | null, files: string[]) => {
if (err) {
console.error(`Error reading directory '${readDirPath}': ${err.message}`);
return;
}
console.log(`Contents of directory '${readDirPath}':`);
files.forEach(file => {
console.log(` - ${file}`);
});
});
// With `withFileTypes` option
fs.readdir(readDirPath, { withFileTypes: true }, (err: NodeJS.ErrnoException | null, dirents: fs.Dirent[]) => {
if (err) {
console.error(`Error reading directory with file types '${readDirPath}': ${err.message}`);
return;
}
console.log(`Contents of directory '${readDirPath}' (with types):`);
dirents.forEach(dirent => {
const type: string = dirent.isFile() ? 'File' : dirent.isDirectory() ? 'Directory' : 'Other';
console.log(` - ${dirent.name} (${type})`);
});
});
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಡೈರೆಕ್ಟರಿ ಓದುವಿಕೆ (fs/promises)
import * as fsPromises from 'fs/promises';
import { Dirent } from 'fs'; // Still use 'fs' module's Dirent interface
async function listDirectoryContents(path: string): Promise
ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಅಳಿಸುವುದು: rmdir (deprecated), rm, rmSync
Node.js ತನ್ನ ಡೈರೆಕ್ಟರಿ ಅಳಿಸುವ ವಿಧಾನಗಳನ್ನು ವಿಕಸನಗೊಳಿಸಿದೆ. fs.rmdir ಈಗ ಹೆಚ್ಚಾಗಿ fs.rm ನಿಂದ ಅತಿಕ್ರಮಿಸಲ್ಪಟ್ಟಿದೆ, ಇದು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಸ್ಥಿರವಾದ API ಅನ್ನು ನೀಡುತ್ತದೆ.
ಅಸಮಕಾಲಿಕ ಡೈರೆಕ್ಟರಿ ಅಳಿಸುವಿಕೆ (fs.rm)
fs.rm ಕಾರ್ಯ (Node.js 14.14.0 ರಿಂದ ಲಭ್ಯವಿದೆ) ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಶಿಫಾರಸು ಮಾಡಲಾದ ಮಾರ್ಗವಾಗಿದೆ. recursive: true ಆಯ್ಕೆಯು ಖಾಲಿಯಲ್ಲದ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಅಳಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
import * as fs from 'fs';
const dirToDeletePath: string = 'data/dir_to_delete';
const nestedDirToDeletePath: string = 'data/nested_dir/sub';
// Setup: Create a directory with a file inside for recursive deletion demo
fs.mkdir(nestedDirToDeletePath, { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('Error creating nested directory for demo:', err);
return;
}
fs.writeFile(`${nestedDirToDeletePath}/file_inside.txt`, 'Some content', (err) => {
if (err) { console.error('Error creating file inside nested directory:', err); return; }
console.log(`Directory '${nestedDirToDeletePath}' and file created for deletion demo.`);
fs.rm(nestedDirToDeletePath, { recursive: true, force: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error deleting recursive directory '${nestedDirToDeletePath}': ${err.message}`);
return;
}
console.log(`Recursive directory '${nestedDirToDeletePath}' deleted successfully.`);
});
});
});
// Deleting an empty directory
fs.mkdir(dirToDeletePath, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('Error creating empty directory for demo:', err);
return;
}
console.log(`Directory '${dirToDeletePath}' created for deletion demo.`);
fs.rm(dirToDeletePath, { recursive: false }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`Error deleting empty directory '${dirToDeletePath}': ${err.message}`);
return;
}
console.log(`Empty directory '${dirToDeletePath}' deleted successfully.`);
});
});
ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ ಡೈರೆಕ್ಟರಿ ಅಳಿಸುವಿಕೆ (fs/promises)
import * as fsPromises from 'fs/promises';
async function deleteDirectory(path: string, recursive: boolean = false): Promise
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಸುಧಾರಿತ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪರಿಕಲ್ಪನೆಗಳು
ಮೂಲಭೂತ ಓದುವ/ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮೀರಿ, Node.js ದೊಡ್ಡ ಫೈಲ್‌ಗಳು, ನಿರಂತರ ಡೇಟಾ ಹರಿವುಗಳು ಮತ್ತು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ನೈಜ-ಸಮಯದ ಮೇಲ್ವಿಚಾರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಶಾಲಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಡಿಕ್ಲರೇಷನ್‌ಗಳು ಈ ಸುಧಾರಿತ ಸನ್ನಿವೇಶಗಳಿಗೆ ಸುಲಭವಾಗಿ ವಿಸ್ತರಿಸುತ್ತವೆ, ದೃಢತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ.
ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರೀಮ್‌ಗಳು
ಅತಿ ದೊಡ್ಡ ಫೈಲ್‌ಗಳಿಗಾಗಿ ಅಥವಾ ಫೈಲ್ ಪ್ರವೇಶದ ಮೇಲೆ ನಿಮಗೆ ಸೂಕ್ಷ್ಮ ನಿಯಂತ್ರಣ ಬೇಕಾದಾಗ (ಉದಾ., ಫೈಲ್‌ನಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನಗಳು), ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರೀಮ್‌ಗಳು ಅತ್ಯಗತ್ಯವಾಗುತ್ತವೆ. ಸ್ಟ್ರೀಮ್‌ಗಳು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು ಚಂಕ್‌ಗಳಲ್ಲಿ ಓದಲು ಅಥವಾ ಬರೆಯಲು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಸ್ಕೇಲೆಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಪರಿಣಾಮಕಾರಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳೊಂದಿಗೆ ಫೈಲ್‌ಗಳನ್ನು ತೆರೆಯುವುದು ಮತ್ತು ಮುಚ್ಚುವುದು (fs.open, fs.close)
ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಎಂಬುದು ತೆರೆದ ಫೈಲ್‌ಗೆ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ನಿಗದಿಪಡಿಸಿದ ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯಾಗಿದೆ (ಸಂಖ್ಯೆ). ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಪಡೆಯಲು ನೀವು fs.open ಅನ್ನು ಬಳಸಬಹುದು, ನಂತರ ಆ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು fs.read ಅಥವಾ fs.write ನಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು ಮತ್ತು ಅಂತಿಮವಾಗಿ ಅದನ್ನು fs.close ಮಾಡಬಹುದು.
import * as fs from 'fs';
import { promises as fsPromises } from 'fs';
import { constants } from 'fs';
const descriptorFilePath: string = 'data/descriptor_example.txt';
async function demonstrateFileDescriptorOperations(): Promise
ಫೈಲ್ ಸ್ಟ್ರೀಮ್‌ಗಳು (fs.createReadStream, fs.createWriteStream)
ಸ್ಟ್ರೀಮ್‌ಗಳು ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಶಾಲಿಯಾಗಿದೆ. fs.createReadStream ಮತ್ತು fs.createWriteStream ಕ್ರಮವಾಗಿ Readable ಮತ್ತು Writable ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ, ಇದು Node.js ನ ಸ್ಟ್ರೀಮಿಂಗ್ API ಯೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಈ ಸ್ಟ್ರೀಮ್ ಈವೆಂಟ್‌ಗಳಿಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅತ್ಯುತ್ತಮ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ (ಉದಾ., `'data'`, `'end'`, `'error'`).
import * as fs from 'fs';
const largeFilePath: string = 'data/large_file.txt';
const copiedFilePath: string = 'data/copied_file.txt';
// Create a dummy large file for demonstration
function createLargeFile(path: string, sizeInMB: number): void {
const content: string = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '; // 56 chars
const stream = fs.createWriteStream(path);
const totalChars = sizeInMB * 1024 * 1024; // Convert MB to bytes
const iterations = Math.ceil(totalChars / content.length);
for (let i = 0; i < iterations; i++) {
stream.write(content);
}
stream.end(() => console.log(`Created large file '${path}' (${sizeInMB}MB).`));
}
// For demonstration, let's ensure the 'data' directory exists first
fs.mkdir('data', { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('Error creating data directory:', err);
return;
}
createLargeFile(largeFilePath, 1); // Create a 1MB file
});
// Copy file using streams
function copyFileWithStreams(source: string, destination: string): void {
const readStream = fs.createReadStream(source);
const writeStream = fs.createWriteStream(destination);
readStream.on('open', () => console.log(`Reading stream for '${source}' opened.`));
writeStream.on('open', () => console.log(`Writing stream for '${destination}' opened.`));
// Pipe data from read stream to write stream
readStream.pipe(writeStream);
readStream.on('error', (err: Error) => {
console.error(`Read stream error: ${err.message}`);
});
writeStream.on('error', (err: Error) => {
console.error(`Write stream error: ${err.message}`);
});
writeStream.on('finish', () => {
console.log(`File '${source}' copied to '${destination}' successfully using streams.`);
// Clean up dummy large file after copy
fs.unlink(largeFilePath, (err) => {
if (err) console.error('Error deleting large file:', err);
else console.log(`Large file '${largeFilePath}' deleted.`);
});
});
}
// Wait a bit for the large file to be created before attempting to copy
setTimeout(() => {
copyFileWithStreams(largeFilePath, copiedFilePath);
}, 1000);
ಬದಲಾವಣೆಗಳಿಗಾಗಿ ವೀಕ್ಷಿಸುವುದು: fs.watch, fs.watchFile
ಬದಲಾವಣೆಗಳಿಗಾಗಿ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು ಹಾಟ್-ರೀಲೋಡಿಂಗ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್‌ಗಳು, ಬಿಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಳು ಅಥವಾ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಪ್ರಮುಖವಾಗಿದೆ. Node.js ಇದಕ್ಕಾಗಿ ಎರಡು ಪ್ರಾಥಮಿಕ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: fs.watch ಮತ್ತು fs.watchFile. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈವೆಂಟ್ ಪ್ರಕಾರಗಳು ಮತ್ತು ಲಿಸನರ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
fs.watch: ಈವೆಂಟ್-ಆಧಾರಿತ ಫೈಲ್ ಸಿಸ್ಟಮ್ ವೀಕ್ಷಣೆ
fs.watch ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಹೆಚ್ಚಾಗಿ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್-ಮಟ್ಟದ ಅಧಿಸೂಚನೆಗಳನ್ನು ಬಳಸುತ್ತದೆ (ಉದಾ., ಲಿನಕ್ಸ್‌ನಲ್ಲಿ inotify, macOS ನಲ್ಲಿ kqueue, ವಿಂಡೋಸ್‌ನಲ್ಲಿ ReadDirectoryChangesW). ಬದಲಾವಣೆಗಳು, ಅಳಿಸುವಿಕೆಗಳು ಅಥವಾ ಮರುಹೆಸರಿಸುವಿಕೆಗಳಿಗಾಗಿ ನಿರ್ದಿಷ್ಟ ಫೈಲ್‌ಗಳು ಅಥವಾ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಇದು ಸೂಕ್ತವಾಗಿದೆ.
import * as fs from 'fs';
const watchedFilePath: string = 'data/watched_file.txt';
const watchedDirPath: string = 'data/watched_dir';
// Ensure files/directories exist for watching
fs.writeFileSync(watchedFilePath, 'Initial content.');
fs.mkdirSync(watchedDirPath, { recursive: true });
console.log(`Watching '${watchedFilePath}' for changes...`);
const fileWatcher = fs.watch(watchedFilePath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`File '${fname || 'N/A'}' event: ${eventType}`);
if (eventType === 'change') {
console.log('File content potentially changed.');
}
// In a real application, you might read the file here or trigger a rebuild
});
console.log(`Watching directory '${watchedDirPath}' for changes...`);
const dirWatcher = fs.watch(watchedDirPath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`Directory '${watchedDirPath}' event: ${eventType} on '${fname || 'N/A'}'`);
});
fileWatcher.on('error', (err: Error) => console.error(`File watcher error: ${err.message}`));
dirWatcher.on('error', (err: Error) => console.error(`Directory watcher error: ${err.message}`));
// Simulate changes after a delay
setTimeout(() => {
console.log('\n--- Simulating changes ---');
fs.appendFileSync(watchedFilePath, '\nNew line added.');
fs.writeFileSync(`${watchedDirPath}/new_file.txt`, 'Content.');
fs.unlinkSync(`${watchedDirPath}/new_file.txt`); // Also test deletion
setTimeout(() => {
fileWatcher.close();
dirWatcher.close();
console.log('\nWatchers closed.');
// Clean up temporary files/dirs
fs.unlinkSync(watchedFilePath);
fs.rmSync(watchedDirPath, { recursive: true, force: true });
}, 2000);
}, 1000);
fs.watch ಕುರಿತು ಗಮನಿಸಿ: ಇದು ಎಲ್ಲಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಎಲ್ಲಾ ರೀತಿಯ ಈವೆಂಟ್‌ಗಳಿಗೆ (ಉದಾ., ಫೈಲ್ ಮರುಹೆಸರಿಸುವಿಕೆಗಳನ್ನು ಅಳಿಸುವಿಕೆಗಳು ಮತ್ತು ರಚನೆಗಳಾಗಿ ವರದಿ ಮಾಡಬಹುದು) ಯಾವಾಗಲೂ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿಲ್ಲ. ದೃಢವಾದ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಫೈಲ್ ವೀಕ್ಷಣೆಗಾಗಿ, chokidar ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಪರಿಗಣಿಸಿ, ಇದು ಹೆಚ್ಚಾಗಿ fs.watch ಅನ್ನು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಬಳಸುತ್ತದೆ ಆದರೆ ನಾರ್ಮಲೈಸೇಶನ್ ಮತ್ತು ಫಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.
fs.watchFile: ಪೋಲಿಂಗ್-ಆಧಾರಿತ ಫೈಲ್ ವೀಕ್ಷಣೆ
fs.watchFile ಬದಲಾವಣೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಪೋಲಿಂಗ್ (ನಿಯತಕಾಲಿಕವಾಗಿ ಫೈಲ್‌ನ stat ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸುವುದು) ಬಳಸುತ್ತದೆ. ಇದು ಕಡಿಮೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಆದರೆ ವಿವಿಧ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಡ್ರೈವ್‌ಗಳಾದ್ಯಂತ ಹೆಚ್ಚು ಸ್ಥಿರವಾಗಿದೆ. fs.watch ವಿಶ್ವಾಸಾರ್ಹವಾಗಿಲ್ಲದ ಪರಿಸರಗಳಿಗೆ (ಉದಾ., NFS ಶೇರ್‌ಗಳು) ಇದು ಉತ್ತಮವಾಗಿ ಸೂಕ್ತವಾಗಿದೆ.
import * as fs from 'fs';
import { Stats } from 'fs';
const pollFilePath: string = 'data/polled_file.txt';
fs.writeFileSync(pollFilePath, 'Initial polled content.');
console.log(`Polling '${pollFilePath}' for changes...`);
fs.watchFile(pollFilePath, { interval: 1000 }, (curr: Stats, prev: Stats) => {
// TypeScript ensures 'curr' and 'prev' are fs.Stats objects
if (curr.mtimeMs !== prev.mtimeMs) {
console.log(`File '${pollFilePath}' modified (mtime changed). New size: ${curr.size} bytes.`);
}
});
setTimeout(() => {
console.log('\n--- Simulating polled file change ---');
fs.appendFileSync(pollFilePath, '\nAnother line added to polled file.');
setTimeout(() => {
fs.unwatchFile(pollFilePath);
console.log(`\nStopped watching '${pollFilePath}'.`);
fs.unlinkSync(pollFilePath);
}, 2000);
}, 1500);
ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಯಾವುದೇ ಉತ್ಪಾದನೆ-ಸಿದ್ಧ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ, ವಿಶೇಷವಾಗಿ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಒಂದಕ್ಕೆ, ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ ಅತ್ಯುನ್ನತವಾಗಿದೆ. ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಹಲವಾರು ಕಾರಣಗಳಿಗಾಗಿ ವಿಫಲವಾಗಬಹುದು: ಅನುಮತಿ ಸಮಸ್ಯೆಗಳು, ಡಿಸ್ಕ್ ತುಂಬಿದ ದೋಷಗಳು, ಫೈಲ್ ಕಂಡುಬಂದಿಲ್ಲ, I/O ದೋಷಗಳು, ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು (ನೆಟ್‌ವರ್ಕ್-ಮೌಂಟೆಡ್ ಡ್ರೈವ್‌ಗಳಿಗೆ) ಅಥವಾ ಏಕಕಾಲೀನ ಪ್ರವೇಶ ಸಂಘರ್ಷಗಳು. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಟೈಪ್-ಸಂಬಂಧಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಹಿಡಿದಿಡಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ರನ್‌ಟೈಮ್ ದೋಷಗಳಿಗೆ ಇನ್ನೂ ಎಚ್ಚರಿಕೆಯ ನಿರ್ವಹಣೆ ಬೇಕಾಗುತ್ತದೆ.
ದೋಷ ನಿರ್ವಹಣೆ ತಂತ್ರಗಳು
- ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು: ಯಾವಾಗಲೂ
try...catchಬ್ಲಾಕ್‌ಗಳಲ್ಲಿfs.xxxSyncಕರೆಗಳನ್ನು ಸುತ್ತುವರಿಯಿರಿ. ಈ ವಿಧಾನಗಳು ನೇರವಾಗಿ ದೋಷಗಳನ್ನು ಎಸೆಯುತ್ತವೆ. - ಅಸಮಕಾಲಿಕ ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು:
fsಕಾಲ್‌ಬ್ಯಾಕ್‌ಗೆ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಯಾವಾಗಲೂerr: NodeJS.ErrnoException | nullಆಗಿರುತ್ತದೆ. ಈerrಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಯಾವಾಗಲೂ ಮೊದಲು ಪರಿಶೀಲಿಸಿ. - ಪ್ರಾಮಿಸ್-ಆಧಾರಿತ (
fs/promises): ನಿರಾಕರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲುawaitನೊಂದಿಗೆtry...catchಅಥವಾ.then()ಚೈನ್‌ಗಳೊಂದಿಗೆ.catch()ಅನ್ನು ಬಳಸಿ.
ದೋಷ ಲಾಗಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಪ್ರಮಾಣೀಕರಿಸುವುದು ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆ ಬಳಕೆದಾರ-ಮುಖವಾಗಿದ್ದರೆ ದೋಷ ಸಂದೇಶಗಳಿಗೆ ಅಂತರರಾಷ್ಟ್ರೀಕರಣವನ್ನು (i18n) ಪರಿಗಣಿಸುವುದು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ.
import * as fs from 'fs';
import { promises as fsPromises } from 'fs';
import * as path from 'path';
const problematicPath = path.join('non_existent_dir', 'file.txt');
// Synchronous error handling
try {
fs.readFileSync(problematicPath, 'utf8');
} catch (error: any) {
console.error(`Sync Error: ${error.code} - ${error.message} (Path: ${problematicPath})`);
}
// Callback-based error handling
fs.readFile(problematicPath, 'utf8', (err, data) => {
if (err) {
console.error(`Callback Error: ${err.code} - ${err.message} (Path: ${problematicPath})`);
return;
}
// ... process data
});
// Promise-based error handling
async function safeReadFile(filePath: string): Promise
ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ: ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಮುಚ್ಚುವುದು
fs.open (ಅಥವಾ fsPromises.open) ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಕಾರ್ಯಾಚರಣೆಗಳು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ದೋಷಗಳು ಸಂಭವಿಸಿದರೂ ಸಹ, fs.close (ಅಥವಾ fileHandle.close()) ಅನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಯಾವಾಗಲೂ ಮುಚ್ಚಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಹಾಗೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ನ ತೆರೆದ ಫೈಲ್ ಮಿತಿಯನ್ನು ತಲುಪಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು ಅಥವಾ ಇತರ ಪ್ರಕ್ರಿಯೆಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು.
FileHandle ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ fs/promises API ಸಾಮಾನ್ಯವಾಗಿ ಇದನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ಏಕೆಂದರೆ fileHandle.close() ಅನ್ನು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು FileHandle ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗಳು Disposable ಆಗಿರುತ್ತವೆ (Node.js 18.11.0+ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ 5.2+ ಬಳಸುತ್ತಿದ್ದರೆ).
ಪಾತ್ ನಿರ್ವಹಣೆ ಮತ್ತು ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಹೊಂದಾಣಿಕೆ
ಫೈಲ್ ಪಾತ್‌ಗಳು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳ ನಡುವೆ ಗಮನಾರ್ಹವಾಗಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ (ಉದಾ., ವಿಂಡೋಸ್‌ನಲ್ಲಿ \, ಯೂನಿಕ್ಸ್-ತರಹದ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ /). Node.js path ಮಾಡ್ಯೂಲ್ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಹೊಂದಾಣಿಕೆಯ ರೀತಿಯಲ್ಲಿ ಫೈಲ್ ಪಾತ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡಲು ಅನಿವಾರ್ಯವಾಗಿದೆ, ಇದು ಜಾಗತಿಕ ನಿಯೋಜನೆಗಳಿಗೆ ಅತ್ಯಗತ್ಯ.
path.join(...paths): ಎಲ್ಲಾ ನೀಡಿದ ಪಾತ್ ವಿಭಾಗಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತದೆ, ಪರಿಣಾಮವಾಗಿ ಪಾತ್ ಅನ್ನು ನಾರ್ಮಲೈಸ್ ಮಾಡುತ್ತದೆ.path.resolve(...paths): ಪಾತ್‌ಗಳ ಅನುಕ್ರಮ ಅಥವಾ ಪಾತ್ ವಿಭಾಗಗಳನ್ನು ಸಂಪೂರ್ಣ ಪಾತ್‌ಗೆ ಪರಿಹರಿಸುತ್ತದೆ.path.basename(path): ಪಾತ್‌ನ ಕೊನೆಯ ಭಾಗವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.path.dirname(path): ಪಾತ್‌ನ ಡೈರೆಕ್ಟರಿ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.path.extname(path): ಪಾತ್‌ನ ವಿಸ್ತರಣೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ path ಮಾಡ್ಯೂಲ್‌ಗೆ ಸಂಪೂರ್ಣ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ನೀವು ಅದರ ಕಾರ್ಯಗಳನ್ನು ಸರಿಯಾಗಿ ಬಳಸುತ್ತೀರಿ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
import * as path from 'path';
const dir = 'my_app_data';
const filename = 'config.json';
// Cross-platform path joining
const fullPath: string = path.join(__dirname, dir, filename);
console.log(`Cross-platform path: ${fullPath}`);
// Get directory name
const dirname: string = path.dirname(fullPath);
console.log(`Directory name: ${dirname}`);
// Get base file name
const basename: string = path.basename(fullPath);
console.log(`Base name: ${basename}`);
// Get file extension
const extname: string = path.extname(fullPath);
console.log(`Extension: ${extname}`);
ಏಕಕಾಲೀನತೆ ಮತ್ತು ರೇಸ್ ಕಂಡೀಶನ್‌ಗಳು
ಹಲವಾರು ಅಸಮಕಾಲಿಕ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿದಾಗ, ವಿಶೇಷವಾಗಿ ಬರೆಯುವಿಕೆಗಳು ಅಥವಾ ಅಳಿಸುವಿಕೆಗಳು, ರೇಸ್ ಕಂಡೀಶನ್‌ಗಳು ಸಂಭವಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಕಾರ್ಯಾಚರಣೆಯು ಫೈಲ್‌ನ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸಿದರೆ ಮತ್ತು ಇನ್ನೊಂದು ಕಾರ್ಯಾಚರಣೆಯು ಮೊದಲ ಕಾರ್ಯಾಚರಣೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಮೊದಲು ಅದನ್ನು ಅಳಿಸಿದರೆ, ಮೊದಲ ಕಾರ್ಯಾಚರಣೆಯು ಅನಿರೀಕ್ಷಿತವಾಗಿ ವಿಫಲವಾಗಬಹುದು.
- ನಿರ್ಣಾಯಕ ಪಾತ್ ತರ್ಕಕ್ಕಾಗಿ
fs.existsSyncಅನ್ನು ತಪ್ಪಿಸಿ;fs.accessಅನ್ನು ಆದ್ಯತೆ ನೀಡಿ ಅಥವಾ ಸರಳವಾಗಿ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ದೋಷವನ್ನು ನಿರ್ವಹಿಸಿ. - ವಿಶೇಷ ಪ್ರವೇಶದ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ, ಸೂಕ್ತವಾದ
flagಆಯ್ಕೆಗಳನ್ನು ಬಳಸಿ (ಉದಾ., ವಿಶೇಷ ಬರವಣಿಗೆಗಾಗಿ `'wx'`). - ಹೆಚ್ಚು ನಿರ್ಣಾಯಕ ಹಂಚಿಕೆಯ ಸಂಪನ್ಮೂಲ ಪ್ರವೇಶಕ್ಕಾಗಿ ಲಾಕಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು (ಉದಾ., ಫೈಲ್ ಲಾಕ್‌ಗಳು, ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್-ಮಟ್ಟದ ಲಾಕ್‌ಗಳು) ಕಾರ್ಯಗತಗೊಳಿಸಿ, ಆದಾಗ್ಯೂ ಇದು ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
ಅನುಮತಿಗಳು (ACL ಗಳು)
ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನುಮತಿಗಳು (ಪ್ರವೇಶ ನಿಯಂತ್ರಣ ಪಟ್ಟಿಗಳು ಅಥವಾ ಪ್ರಮಾಣಿತ ಯೂನಿಕ್ಸ್ ಅನುಮತಿಗಳು) ದೋಷಗಳ ಸಾಮಾನ್ಯ ಮೂಲಗಳಾಗಿವೆ. ನಿಮ್ಮ Node.js ಪ್ರಕ್ರಿಯೆಯು ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಓದಲು, ಬರೆಯಲು ಅಥವಾ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಗತ್ಯ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಕಂಟೈನರೈಸ್ಡ್ ಪರಿಸರಗಳಲ್ಲಿ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರ ಖಾತೆಗಳೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಬಹು-ಬಳಕೆದಾರ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಪ್ರಸ್ತುತವಾಗಿದೆ.
ತಿರ್ಮಾನ: ಜಾಗತಿಕ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು
Node.js fs ಮಾಡ್ಯೂಲ್ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಶಕ್ತಿಶಾಲಿ ಮತ್ತು ಬಹುಮುಖ ಸಾಧನವಾಗಿದೆ, ಇದು ಮೂಲಭೂತ ಫೈಲ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳಿಂದ ಸುಧಾರಿತ ಸ್ಟ್ರೀಮ್-ಆಧಾರಿತ ಡೇಟಾ ಸಂಸ್ಕರಣೆಯವರೆಗೆ ಹಲವಾರು ಆಯ್ಕೆಗಳನ್ನು ನೀಡುತ್ತದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಮೇಲೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಲೇಯರ್ ಮಾಡುವುದರಿಂದ, ನೀವು ಅಮೂಲ್ಯವಾದ ಪ್ರಯೋಜನಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ: ಸಂಕಲನದ ಸಮಯದಲ್ಲಿ ದೋಷ ಪತ್ತೆ, ವರ್ಧಿತ ಕೋಡ್ ಸ್ಪಷ್ಟತೆ, ಉತ್ತಮ ಟೂಲಿಂಗ್ ಬೆಂಬಲ ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚಿದ ವಿಶ್ವಾಸ. ವಿವಿಧ ಕೋಡ್‌ಬೇಸ್‌ಗಳಾದ್ಯಂತ ಸ್ಥಿರತೆ ಮತ್ತು ಕಡಿಮೆಯಾದ ಅಸ್ಪಷ್ಟತೆ ಅತ್ಯಗತ್ಯವಾದ ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ನೀವು ಸಣ್ಣ ಯುಟಿಲಿಟಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ ಅಥವಾ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಎಂಟರ್‌ಪ್ರೈಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ನಿಮ್ಮ Node.js ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ದೃಢವಾದ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ, ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ದೋಷ-ನಿರೋಧಕ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಕ್ಲೀನರ್ ಅಸಮಕಾಲಿಕ ಮಾದರಿಗಳಿಗಾಗಿ fs/promises API ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ, ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕರೆಗಳ ನಡುವಿನ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ ಮತ್ತು ಯಾವಾಗಲೂ ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಪಾತ್ ನಿರ್ವಹಣೆಗೆ ಆದ್ಯತೆ ನೀಡಿ.
ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ತತ್ವಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವಯಿಸುವುದರ ಮೂಲಕ, ವಿಶ್ವಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳು ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾದ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸಂವಹನಗಳನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಆಂತರಿಕವಾಗಿ ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಮತ್ತು ತರ್ಕಬದ್ಧವಾದವುಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು, ಅಂತಿಮವಾಗಿ ಉತ್ತಮ ಗುಣಮಟ್ಟದ ಸಾಫ್ಟ್‌ವೇರ್ ವಿತರಣೆಗಳಿಗೆ ಕೊಡುಗೆ ನೀಡಬಹುದು.